int mi_vector[VALOR];
void crear_vector(int tamanio, int *mi_vector);
void imprimir_vector(int tamanio, int *mi_vector);
void ordenar_vector(int tamanio, int *vector);
int main(){
printf("Vector de 100 numeros aleatorios entre 0 y
1000nn");
crear_vector(VALOR, mi_vector);
imprimir_vector(VALOR, mi_vector);
printf("n");
printf("Vector 'ordenado' de 100 numeros aleatorios entre 0 y
1000nn");
ordenar_vector(VALOR, mi_vector);
imprimir_vector(VALOR, mi_vector);
return 0;
}
void crear_vector(int tamanio, int *vector){
srand(time(NULL));
int valor;
int i;
for(i=0; i<tamanio; i++){
do{
valor = rand();
} while (valor > 1000 || valor < 0);
vector[i] = valor;
}
}
void imprimir_vector(int tamanio, int *vector){
int i;
for(i=0; i<tamanio; i++){
printf("Vector impreso: %dn", vector[i]);
}
}
void ordenar_vector(int tamanio, int *vector){
int minj;
int minx;
int i;
for (i=0; i < tamanio; i++){
minj = i;
minx = vector[i];
int j;
for (j = i; j < tamanio ; j++){
if (vector[j] < minx){
minj = j;
minx = vector[j];
}
}
vector[minj] = vector[i];
vector[i] = minx;
}
}
///////////////////////////////////////////////////////////////
// Practico 2 – Arrays – Ejercicio 3
//
// Dada una lista de 20 numeros enteros ordenada de menor a
mayor en un vector,
// generar al azar 10 numeros enteros (o ingresarlos por la
entrada estandar) e
// insertar los mismos en la lista de numeros manteniendo
el orden.
// Desplegar la lista final.
//
// (Falta terminar)
//////////////////////////////////////////////////////
#include <stdio.h>
#include
<stdlib.h>
// srand(), rand()
#include
<time.h>
// para el time()
//RAND_MAX = 1000; como funciona esto ????
#define VALOR 20
#define OTROVALOR 10
int mi_vector[VALOR] = {10, 20, 30, 40, 50, 60, 70, 80, 90,
100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200};
int otro_vector[OTROVALOR];
int vector_intercalado[VALOR+OTROVALOR];
void crear_vector(int tamanio, int *mi_vector);
void imprimir_vector(int tamanio, int *mi_vector);
//void intercalar_vector(int tamanio, int otro_tamanio, int
tamanio_intercalado, int *vector, int *otro_vector, int
*vector_intercalado){
int main(){
printf("Vector de 20 numeros:nn");
imprimir_vector(VALOR, mi_vector);
printf("Vector de 10 numeros al azar:nn");
crear_vector(OTROVALOR, otro_vector);
imprimir_vector(OTROVALOR, otro_vector);
printf("nn");
printf("Vector de 30 numeros intercalados:nn");
//intercalar_vector(VALOR, OTROVALOR, VALOR+OTROVALOR, mi_vector,
otro_vector, vector_intercalado);
imprimir_vector(VALOR+OTROVALOR, vector_intercalado);
return 0;
}
void crear_vector(int tamanio, int *vector){
srand(time(NULL));
int valor;
int i;
for(i=0; i<tamanio; i++){
do{
valor = rand();
} while (valor > 200 || valor < 0);
vector[i] = valor;
}
}
void imprimir_vector(int tamanio, int *vector){
int i;
for(i=0; i<tamanio; i++){
printf("Vector impreso: %dn", vector[i]);
}
}
/*
void intercalar_vector(int tamanio, int otro_tamanio, int
tamanio_intercalado, int *vector, int *otro_vector, int
*vector_intercalado){
int minj;
int minx;
int i;
for (i=0; i < tamanio; i++){
minj = i;
minx = vector[i];
int j;
for (j = i; j < tamanio ; j++){
if (vector[j] < minx){
minj = j;
minx = vector[j];
}
}
vector[minj] = vector[i];
vector[i] = minx;
}
}
SPRINGS
///////////////////////////////////////////////////
// Practico 2 – Springs – Ejercicio 6
//
// Realice un programa (una
variante del clasico Hello world) que solicite
// un nombre por el teclado
(stdin) y luego despliegue por pantalla (stdout)
// el saludo "Hello nombre!!!".
//
// (Funcionando)
//////////////////////////////////////
#include<stdio.h>
int main(){
char nombre[100];
char *pchar;
printf("Ingrese su nombre:n");
gets(nombre);
//puts(nombre);
// cual es la diferencia entre puts y printf ????
printf("Hola %s !!!", nombre);
return 0;
}
////////////////////////////////////////////////
// Practico 2 – Strings – Ejercicio 7
//
// Realice un programa que pida el ingreso de una palabra
por teclado de no mas
// de MAX_CHARS caracteres y que la despliegue de forma
inversa.
// MAX_CHARS es una constante que debera definir en el
programa.
// Se sugiere investigar las funciones int
getchar(void) eint putchar(int c).
//
// (Funcionando)
////////////////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#define MAX_CHARS 10
int main(){
// porque funciona con un tamaño más grande que 10
????
char palabra[MAX_CHARS];
//int *pchar;
//pchar = (int)palabra;
printf("Ingrese una palabra:n");
gets(palabra);
int tamanio = strlen(palabra);
//printf("%d", tamanio);
//printf("%s", palabra);
int i;
for(i = tamanio; i>=0; i–){
printf("%c", palabra[i-1]);
}
// Ver esta opción
//int c = getchar();
//while (c != EOF){
//pchar = getchar();
//pchar++;
//}
//putchar(*pchar);
return 0;
}
//////////////////////////////////////////////
// Practico 2 – Strings – Ejercicio 8
//
// Realice un programa que pida el ingreso de una palabra
por teclado de no mas
// de MAX_CHARS caracteres y que detecte si la palabra es
palindroma.
// MAX_CHARS es una constante que debera definir en el
programa.
//
// (Funcionando)
////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#define MAX_CHARS 10
int main(){
// porque funciona con un tamaño más grande que 10
????
char palabra[MAX_CHARS];
printf("Ingrese una palabra:n");
gets(palabra);
int tamanio = strlen(palabra);
int palindroma = 0;
int i;
// como se hace con un Do While para no recorrer
// todo si en un momento ya no es palindroma????
for(i = 0; i <= tamanio/2; i++){ // voy solo
hasta la mitad de la palabra
if(palabra[i] == palabra[tamanio-1]){
palindroma = 1;
}
tamanio = tamanio-1;
}
if (palindroma == 1){
printf("La palabra es palindroma");
}
else{
printf("La palabra no es palindroma");
}
return 0;
}
PUNTEROS
////////////////////////////////////////////////////
// Practico 2 – Punteros – Ejercicio 11
//
// Reserve lugar para un puntero de tipo int, char, float,
double, luego imprima
// el tamaño de estos tipos de datos
(sizeof). Saque conclusiones.
//
// (Funcionando)
/////////////////////////////////////////
#include<stdio.h>
#include<stdlib.h>
int main(){
int *pint;
float *pfloat;
double *pdouble;
char *pchar;
// void *malloc(size_t tamanyo);
// Adjudica espacio para un objeto, cuyo tamaño es
especificado por tamanyo y cuyo
// valor es indeterminado.
// La función
malloc retorna un puntero nulo o un puntero al espacio
adjudicado.
pint = (int*)malloc(sizeof(int));
pfloat = (float*)malloc(sizeof(float));
pdouble = (double*)malloc(sizeof(double));
pchar = (char*)malloc(sizeof(char));
printf("El tamanio de un int es: %d bytesn", sizeof(int));
printf("El tamanio de un float es: %d bytesn",
sizeof(float));
printf("El tamanio de un double es: %d bytesn",
sizeof(double));
printf("El tamanio de un char es: %d bytesn", sizeof(char));
return 0;
}
////////////////////////////////////////////////////
// Practico 2 – Punteros – Ejercicio 12
//
// Inicialice una variable de tipo int con un valor
cualquiera, inicialice un
// puntero de tipo int para que apunte a la variable antes
creada. Imprima la
// direccion de dicha variable y luego imprima el contenido
del puntero.
// Asimismo imprima "lo apuntado por" el puntero.
//
// (Funcionando)
////////////////////////////////////////////////////
#include<stdio.h>
#include<stdlib.h>
int main(){
int numero = 9;
int *pint;
pint = №
printf("El contenido de numero es: %dn", numero);
printf("La direccion de numero es: %pn", &numero);
// lo de abajo no se puede hacer porque el contenido
// de una variable es ella misma.
// printf("El contenido de numero es: %dn", *numero);
printf("El contenido del puntero que apunta a numero es: %pn",
pint);
printf("La direccion de memoria donde
esta el puntero es: %pn", &pint);
printf("Lo apuntado por el puntero es: %dn", *pint);
return 0;
}
/////////////////////////////////////////////////
// Practico 2 – Punteros – Ejercicio 13
//
// Dada una cadena de caracteres apuntada por la variable
definida como char *s
// realice un programa que recorra la misma utilizando un
unico puntero
// y despliegue los caracteres por la salida estandar uno a
uno junto con el
// valor ascii. Utilice el
minimo codigo
posible.
//
// (Funcionando)
///////////////////////////////////////////////////////////////////
#include<stdio.h>
#include<string.h>
int main(){
// Opción cadena dinamica, como se hace ????
// s = (char*)malloc(sizeof(char));
// Opción cadena estatica
char cadena[100] = "Hola";
char
*s;
// declaracion de puntero a char llamado 's'
s =
cadena;
// el puntero apunta al string 'cadena'
// Opcion 1 – Con un while
while (*s != ''){
printf("Letra %c – ASCII %in", *s, *s);
s++;
}
// Opcion 2 – Con un for
int i;
for (i=0; *s != ''; s++){
printf("Letra %c – ASCII %in", *s, *s);
}
return 0;
}
//////////////////////////////////////////////
Autor:
Gastón
Uruguay
 Página anterior | Volver al principio del trabajo | Página siguiente  |